From: Yehuda Katz Date: Wed, 30 Apr 2014 22:23:03 +0000 (-0700) Subject: API for SerializedManifest->Manifest and other org X-Git-Tag: archive/raspbian/0.35.0-2+rpi1~3^2^2^2^2^2^2^2~1102 X-Git-Url: https://dgit.raspbian.org/%22http://www.example.com/cgi/success//%22http:/www.example.com/cgi/success/?a=commitdiff_plain;h=0e619d88c81928f9302e2d27237e1c72746e3b83;p=cargo.git API for SerializedManifest->Manifest and other org Also fleshed out the Package struct. Setting up to convert a vec of project paths into a vec of Packages to pass to cargo-rustc. --- diff --git a/src/cargo/core/dependency.rs b/src/cargo/core/dependency.rs index 6b1e11da9..80d2356c5 100644 --- a/src/cargo/core/dependency.rs +++ b/src/cargo/core/dependency.rs @@ -1,6 +1,6 @@ use core; -#[deriving(Eq,Clone,Show)] +#[deriving(Eq,Clone,Show,Encodable,Decodable)] pub struct Dependency { name: core::NameVer } @@ -10,6 +10,10 @@ impl Dependency { Dependency { name: core::NameVer::new(name.to_owned(), "1.0.0") } } + pub fn with_namever(name: &core::NameVer) -> Dependency { + Dependency { name: name.clone() } + } + pub fn with_name_and_version(name: &str, version: &str) -> Dependency { Dependency { name: core::NameVer::new(name, version) } } diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs index d4a4c6801..c58866e11 100644 --- a/src/cargo/core/manifest.rs +++ b/src/cargo/core/manifest.rs @@ -1,19 +1,60 @@ use core::NameVer; +use core::dependency::Dependency; +use collections::HashMap; +use {CargoResult,ToCargoError}; /* * TODO: Make all struct fields private */ -#[deriving(Decodable,Encodable,Eq,Clone,Ord)] +#[deriving(Decodable,Encodable,Eq,Clone)] +pub struct SerializedManifest { + project: ~Project, + lib: Option<~[SerializedLibTarget]>, + bin: Option<~[SerializedExecTarget]>, + dependencies: Option> +} + +#[deriving(Decodable,Encodable,Eq,Clone)] +struct SerializedTarget { + name: ~str, + path: Option<~str> +} + +type SerializedLibTarget = SerializedTarget; +type SerializedExecTarget = SerializedTarget; + +#[deriving(Decodable,Encodable,Eq,Clone)] pub struct Manifest { pub project: ~Project, pub root: ~str, pub lib: ~[LibTarget], pub bin: ~[ExecTarget], - pub dependencies: Vec + pub target: ~str, + pub dependencies: Vec } impl Manifest { + pub fn from_serialized(path: &str, serialized: &SerializedManifest) -> CargoResult { + let (lib,bin) = normalize(&serialized.lib, &serialized.bin); + let &SerializedManifest { ref project, ref dependencies, .. } = serialized; + + let deps = dependencies.clone().map(|deps| { + deps.iter().map(|(k,v)| { + Dependency::with_namever(&NameVer::new(k.clone(), v.clone())) + }).collect() + }).unwrap_or_else(|| vec!()); + + Ok(Manifest { + root: try!(Path::new(path.to_owned()).dirname_str().to_cargo_error(format!("Could not get dirname from {}", path), 1)).to_owned(), + project: project.clone(), + lib: lib, + bin: bin, + target: ~"target", + dependencies: deps + }) + } + pub fn get_name_ver(&self) -> NameVer { NameVer::new(self.project.name.as_slice(), self.project.version.as_slice()) } @@ -23,19 +64,49 @@ impl Manifest { } } -#[deriving(Decodable,Encodable,Eq,Clone,Ord)] +fn normalize(lib: &Option<~[SerializedLibTarget]>, bin: &Option<~[SerializedExecTarget]>) -> (~[LibTarget], ~[ExecTarget]) { + fn lib_targets(libs: &[SerializedLibTarget]) -> ~[LibTarget] { + let l = &libs[0]; + let path = l.path.clone().unwrap_or_else(|| format!("src/{}.rs", l.name)); + ~[LibTarget { path: path, name: l.name.clone() }] + } + + fn bin_targets(bins: &[SerializedExecTarget], default: |&SerializedExecTarget| -> ~str) -> ~[ExecTarget] { + bins.iter().map(|bin| { + let path = bin.path.clone().unwrap_or_else(|| default(bin)); + ExecTarget { path: path, name: bin.name.clone() } + }).collect() + } + + match (lib, bin) { + (&Some(ref libs), &Some(ref bins)) => { + (lib_targets(libs.as_slice()), bin_targets(bins.as_slice(), |bin| format!("src/bin/{}.rs", bin.name))) + }, + (&Some(ref libs), &None) => { + (lib_targets(libs.as_slice()), ~[]) + }, + (&None, &Some(ref bins)) => { + (~[], bin_targets(bins.as_slice(), |bin| format!("src/{}.rs", bin.name))) + }, + (&None, &None) => { + (~[], ~[]) + } + } +} + +#[deriving(Decodable,Encodable,Eq,Clone,Show)] pub struct ExecTarget { pub name: ~str, pub path: ~str } -#[deriving(Decodable,Encodable,Eq,Clone,Ord)] +#[deriving(Decodable,Encodable,Eq,Clone,Show)] pub struct LibTarget { pub name: ~str, pub path: ~str } -#[deriving(Decodable,Encodable,Eq,Clone,Ord)] +#[deriving(Decodable,Encodable,Eq,Clone,Show)] pub struct Project { pub name: ~str, pub version: ~str, diff --git a/src/cargo/core/mod.rs b/src/cargo/core/mod.rs index 49ee02f38..99beeb8ff 100644 --- a/src/cargo/core/mod.rs +++ b/src/cargo/core/mod.rs @@ -24,6 +24,6 @@ pub mod namever; pub mod source; pub mod package; pub mod dependency; -mod manifest; +pub mod manifest; mod registry; mod resolver; diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs index a54663860..4ddae1ebd 100644 --- a/src/cargo/core/package.rs +++ b/src/cargo/core/package.rs @@ -1,6 +1,8 @@ use std::vec::Vec; use semver; use core; +use core::{NameVer,Dependency}; +use core::manifest::{Manifest,LibTarget}; /** * Represents a rust library internally to cargo. This will things like where @@ -14,13 +16,25 @@ pub struct Package { name_ver: core::NameVer, deps: Vec, root: ~str, - source: ~str, + source: LibTarget, target: ~str } impl Package { - pub fn new(name: &core::NameVer, deps: &Vec, root: &str, source: &str, target: &str) -> Package { - Package { name_ver: name.clone(), deps: deps.clone(), root: root.to_owned(), source: source.to_owned(), target: target.to_owned() } + pub fn new(name: &core::NameVer, deps: &Vec, root: &str, source: &LibTarget, target: &str) -> Package { + Package { name_ver: name.clone(), deps: deps.clone(), root: root.to_owned(), source: source.clone(), target: target.to_owned() } + } + + pub fn from_manifest(manifest: &Manifest) -> Package { + let project = &manifest.project; + + Package { + name_ver: core::NameVer::new(project.name.as_slice(), project.version.as_slice()), + deps: manifest.dependencies.clone(), + root: manifest.root.clone(), + source: manifest.lib.as_slice().get(0).unwrap().clone(), + target: manifest.target.clone() + } } pub fn get_name<'a>(&'a self) -> &'a str { @@ -35,8 +49,8 @@ impl Package { self.root.as_slice() } - pub fn get_source<'a>(&'a self) -> &'a str { - self.source.as_slice() + pub fn get_source<'a>(&'a self) -> &'a LibTarget { + &self.source } pub fn get_target<'a>(&'a self) -> &'a str { diff --git a/src/cargo/ops/cargo_read_manifest.rs b/src/cargo/ops/cargo_read_manifest.rs index 7223e5a88..b2c0c60b4 100644 --- a/src/cargo/ops/cargo_read_manifest.rs +++ b/src/cargo/ops/cargo_read_manifest.rs @@ -3,26 +3,7 @@ use hammer::FlagConfig; use serialize::Decoder; use toml::from_toml; use {CargoResult,ToCargoError,core}; -use std::path::Path; -use collections::HashMap; -use core::NameVer; - -#[deriving(Decodable,Encodable,Eq,Clone)] -struct SerializedManifest { - project: ~core::Project, - lib: Option<~[SerializedLibTarget]>, - bin: Option<~[SerializedExecTarget]>, - dependencies: HashMap<~str, ~str> -} - -#[deriving(Decodable,Encodable,Eq,Clone)] -pub struct SerializedTarget { - name: ~str, - path: Option<~str> -} - -pub type SerializedLibTarget = SerializedTarget; -pub type SerializedExecTarget = SerializedTarget; +use core::manifest::{SerializedManifest,Manifest}; #[deriving(Decodable,Eq,Clone,Ord)] @@ -45,45 +26,7 @@ pub fn execute(flags: ReadManifestFlags) -> CargoResult> let toml_manifest = try!(from_toml::(root.clone()).to_cargo_error(|e: toml::Error| format!("Couldn't parse Toml file: {:?}", e), 1)); - let (lib, bin) = normalize(&toml_manifest.lib, &toml_manifest.bin); - - let SerializedManifest { project, dependencies, .. } = toml_manifest; - - Ok(Some(core::Manifest { - root: try!(Path::new(manifest_path.clone()).dirname_str().to_cargo_error(format!("Could not get dirname from {}", manifest_path), 1)).to_owned(), - project: project, - lib: lib, - bin: bin, - dependencies: dependencies.iter().map(|(k,v)| NameVer::new(k.clone(),v.clone())).collect() - })) -} - -fn normalize(lib: &Option<~[SerializedLibTarget]>, bin: &Option<~[SerializedExecTarget]>) -> (~[core::LibTarget], ~[core::ExecTarget]) { - fn lib_targets(libs: &[SerializedLibTarget]) -> ~[core::LibTarget] { - let l = &libs[0]; - let path = l.path.clone().unwrap_or_else(|| format!("src/{}.rs", l.name)); - ~[core::LibTarget { path: path, name: l.name.clone() }] - } - - fn bin_targets(bins: &[SerializedExecTarget], default: |&SerializedExecTarget| -> ~str) -> ~[core::ExecTarget] { - bins.iter().map(|bin| { - let path = bin.path.clone().unwrap_or_else(|| default(bin)); - core::ExecTarget { path: path, name: bin.name.clone() } - }).collect() - } - - match (lib, bin) { - (&Some(ref libs), &Some(ref bins)) => { - (lib_targets(libs.as_slice()), bin_targets(bins.as_slice(), |bin| format!("src/bin/{}.rs", bin.name))) - }, - (&Some(ref libs), &None) => { - (lib_targets(libs.as_slice()), ~[]) - }, - (&None, &Some(ref bins)) => { - (~[], bin_targets(bins.as_slice(), |bin| format!("src/{}.rs", bin.name))) - }, - (&None, &None) => { - (~[], ~[]) - } - } + Manifest::from_serialized(manifest_path.as_slice(), &toml_manifest).map(|manifest| { + Some(manifest) + }) }